package com.edu.whty.common.tools;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.InputStream;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具类
 *
 * @author hhb
 * @version 1.0
 */
public class StringUtil {
    private static final Log LOG=LogFactory.getLog(StringUtil.class);
    private final static String[] hexDigits = {"0", "1", "2", "3", "4", "5",
            "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};

    /**
     * 转换字节数组为16进制字符串
     *
     * @param b 字节数组
     * @return 16进制字符串
     */
    private static String byteArrayToHexString(byte[] bty) {
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < bty.length; i++) {
        	stringBuffer.append(byteToHexString(bty[i]));
        }

        return stringBuffer.toString();
    }

    /**
     * 转换字节数为16进制字符串
     *
     * @param b byte数值
     * @return 16进制字符串
     */
    private static String byteToHexString(byte byt) {
        int now = byt;
        if (now < 0) {
            now = 256 + now;
        }
        int do1 = now / 16;
        int do2 = now % 16;

        return hexDigits[do1] + hexDigits[do2];
    }

    /**
     * 获取指定字符串的MD5编码
     *
     * @param original 字符串
     * @return MD5编码
     */
    public static String MD5Encode(String original) {
        String ret = null;

        try {
            ret = original;
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            ret = byteArrayToHexString(messageDigest.digest(ret.getBytes()));
        } catch (Exception ex) {
            LOG.error(ex.getMessage(),ex);
        }

        return ret;
    }

    /**
     * 获得0-9的随机数字符串
     *
     * @param length 返回字符串的长度
     * @return String
     */
    public static String getRandomNumber(int length) {
        Random random = new Random();
        StringBuffer buffer = new StringBuffer();

        for (int i = 0; i < length; i++) {
            buffer.append(random.nextInt(10));
        }
        return buffer.toString();
    }

    /**
     * 获得0-9,a-z,A-Z范围的随机字符串
     *
     * @param length 字符串长度
     * @return String
     */
    public static String getRandomChar(int length) {
        char[] chr = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
                'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
                'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
                'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
                'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
                'X', 'Y', 'Z'};

        Random random = new Random();
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < length; i++) {
            buffer.append(chr[random.nextInt(62)]);
        }

        return buffer.toString();
    }

    /**
     * 判断字符串数组中是否包含某字符串
     *
     * @param substring 某字符串
     * @param source    源字符串数组
     * @return 包含则返回true，否则返回false
     */
    public static boolean isContains(String substring, String[] source) {
        if (source == null || source.length == 0) {
            return false;
        }

        for (int i = 0; i < source.length; i++) {
            String aSource = source[i];
            if (aSource.equals(substring)) {
                return true;
            }
        }

        return false;
    }

    /**
     * 判断字符是否为空
     *
     * @param str 某字符串
     * @return 为null或为空串则返回true，否则返回false
     */
    public static boolean isEmpty(String str) {
        return str == null || str.length() == 0;
    }
    
    /**
     * 判断字符是否不为空
     *
     * @param str 某字符串
     * @return 为null或为空串则返回false，否则返回true
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 首字母大写
     *
     * @param str 字符串
     * @return 首字符大写后的字符串
     */
    public static String upFirstChar(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }

    /**
     * 首字母小写
     *
     * @param str 字符串
     * @return 首字符大写后的字符串
     */
    public static String lowerFirstChar(String str) {
        return str.substring(0, 1).toLowerCase() + str.substring(1);
    }
    
    /**
     * 字符串数组转成列表
     * @param arr
     * @return
     */
    public static List<String> StringsToList(String [] arr){
    	List<String> strList = null;
    	if(null == arr){
    		return strList;
    	}
    	strList = new ArrayList<String>();
    	for(int i = 0;i < arr.length;i++){
    		strList.add(arr[i]);
    	}
    	return strList;
    }
    
    /**
     * inputstream解析成string
     * @param input
     * @return
     */
    public static String inputStream2String(InputStream input) {
		try{
			StringBuffer out = new StringBuffer();
			byte[] byt = new byte[4096];
			for (int n; (n = input.read(byt)) != -1;) {
				out.append(new String(byt, 0, n));
			}
			return out.toString();
		}catch(Exception e){
			//e.printStackTrace();
			LOG.error(e.getMessage(),e);
		}
		return "";
	}
    /**
     * 替换url
     * @param input
     * @return
     */
    public static String replaceURL(Object object) {
    	 String oldquc =null;
			if (object != null) {
				Pattern pt = Pattern
				.compile("<img\\s.*?src=\\\"([^\"]+)\\\"[^>]*>");
				Matcher m = pt.matcher(object.toString());
				oldquc=object.toString();
				while (m.find()) {
					String oldurl = m.group(1);
					if (oldurl.contains("Upload")) {
						// 替换处理
						String newurl=SysConfig.getStrValue("IMGE_URL")+oldurl;
						oldquc=oldquc.replace(oldurl, newurl);
						
					}
			}
		}
    	return oldquc;
    }
    
	/**
	 * 判断对象是否为空
	 * 
	 * @param o
	 * @return
	 */
	public static boolean isNotNull(Object o) {
		if (o == null) {
			return false;
		} else if (o instanceof String && "".equals(((String) o).trim())) {
			return false;
		} else {
			return true;
		}
	}
	
	/**
	 * 阿拉伯数字转换为中文数值，八转化为八，11转换为十一
	 * @param value
	 * @return
	 */
	public static String numberToBig(int value) {
		char[] hunit = { '十', '百', '千' }; // 段内位置表示
		char[] vunit = { '万', '亿' }; // 段名表示
		char[] digit = { '〇', '一', '二', '三', '四', '五', '六', '七', '八', '九' }; // 数字表示
		long midVal = (long) (value * 100 + 0.5); // 转化成整形,四舍五入
		String valStr = String.valueOf(midVal); // 转化成字符串
		String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
//		String rail = valStr.substring(valStr.length() - 2); // 取小数部分

		String prefix = ""; // 整数部分转化的结果
//		String suffix = ""; // 小数部分转化的结果
//		// 处理小数点后面的数
//		if (rail.equals("00")) { // 如果小数部分为0
//			suffix = "整";
//		} else {
//			suffix = digit[rail.charAt(0) - '0'] + "角"
//					+ digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
//		}
		// 处理小数点前面的数
		char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
		boolean preZero = false; // 标志当前位的上一位是否为有效0位（如万位的0对千位无效）
		byte zeroSerNum = 0; // 连续出现0的次数
		for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字
			int idx = (chDig.length - i - 1) % 4; // 取段内位置
			int vidx = (chDig.length - i - 1) / 4; // 取段位置

			if (chDig[i] == '0') { // 如果当前字符是0
				preZero = true;
				zeroSerNum++; // 连续0次数递增
				if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
					prefix += vunit[vidx - 1];
					preZero = false; // 不管上一位是否为0，置为无效0位
				}
			} else {
				zeroSerNum = 0; // 连续0次数清零
				if (preZero) { // 上一位为有效0位
					prefix += digit[0]; // 只有在这地方用到'零'
					preZero = false;
				}
				prefix += digit[chDig[i] - '0']; // 转化该数字表示
				if (idx > 0)
					prefix += hunit[idx - 1];
				if (idx == 0 && vidx > 0) {
					prefix += vunit[(vidx + 1) % 2];
					for (int j = 0; j < (vidx + 1) / 2 - 1; j++) {
						prefix += vunit[1];
					}
				}
			}
		}
//		if (prefix.length() > 0)
//			prefix += '圆'; // 如果整数部分存在,则有圆的字样
//		return prefix + suffix; // 返回正确表示
		
		if (prefix.startsWith("一十")) {
			prefix = prefix.substring(1);
		}
		return prefix;
	}
	
	
}
